• 按一定顺序排列的同类型数据的集合称为数组，本身是一种引用类型

声明

int[] arr; // 数组元素类型[] 数组名;
int arr[]; // 数组元素类型 数组名[]; // 不推荐

初始化

// 静态初始化
// 数组名 = new 数组元素类型[] {元素 1, 元素 2, ...};
// 在堆空间开辟一块内存区域来存储数组的元素（new）
// 将 该内存区域的地址值 赋值给 该数组的引用变量 arr（引用）
int[] arr = new int[] {1, 2, 3};

// 简单写法，必须声明的同时作初始化
// 数组元素类型[] 数组名 = {元素 1, 元素 2, ...};
int[] arr = {1, 2, 3};

// 动态初始化，系统自动为数组元素分配初始值
// 数组名 = new 数组元素类型[length];
int[] arr = new int[3]; // [0, 0, 0]

• 变量必须初始化后才能使用

• 数组是定长的：数组一旦初始化完成，数组的长度就固定了，不能更改，除非重新做初始化

• 数组是引用数据类型，可以赋值为 null，表示没有引用任何内存空间

• new 关键字：在堆空间开辟一块内存区域，用来存储数据

• 操作数组常见异常：
  NullPointerException：空指针异常（没有引用地址值）
  ArrayIndexOutOfBoundsException：数组的索引越界异常

基本操作

int[] arr = new int[] {1, 2, 3};

// 访问数组元素  数组变量[索引值]
int len = arr.length;  // 数组长度，length 是属性，索引范围 [0, arr.length - 1]
int num = arr[0];
arr[0] = 11;

// 遍历
// 普通 for 循环
for (int i = 0; i < arr.length; i++) {
    System.out.println(arr[i]);
}

// 增强 for 循环（for-each）
// 只能访问数组元素，不能赋值，不关心数组的索引时使用
// 当数组元素是引用类型时，不建议使用（需要先知道值不为 null 的元素个数）
for (int ele : arr) {
    System.out.println(ele);
}

// 反编译后
int ai[] = arr;
int k = ai.length;
for (int j = 0; j < k; j++) {
    int i = ai[j]; // 使用循环迭代出数组中的每一个元素并赋值给 i
    System.out.println(i); // 操作 i
}

// 打印数组元素
// 直接打印数组名时，打印出来是数组对应的 hashCode 值，如 [I@15db9742, [D@15db9742, [Ljava.lang.String;@15db9742
static String toString(int[] arr) {
    // 判断数组是否为空
    if (arr == null) {
        return "null"; // 结束方法
    }
    if (arr.length == 0) {
        return "[]";
    }
    
    String ret = "["; // 先拼接"["
    for (int index = 0; index < arr.length; index++) {
        // 如果不是最后一个元素，拼接 元素 + ", "，否则拼接 元素 + "]"
        ret = (index != arr.length - 1) 
            ? ret + arr[index] + ", " 
            : ret + arr[index] + "]";
    }
    return ret;
}

二维数组

• 实质还是一维数组， 其数组元素是引用类型（ 数组类型）， 数组元素里保存的引用指向一维数组

• 定义格式

  // 静态初始化
  int[][] arr = new int[][] { {1, 2, 3}, {4, 5}, {6} };
  int[][] arr = { {1, 2, 3}, {4, 5}, {6} };
  // 动态初始化
  int[][] arr = new int[3][]; // 等同于 int[][] arr = {null, null, null};
  int[][] arr = new int[3][4];
  // arr.length 为外层数组的长度，arr[i].length 为内层每个数组的长度
  
  // 遍历
  // 普通 for 循环
  for (int i = 0; i < nums.length; i++) {
      for (int j = 0; j < nums[i].length; j++) {
          System.out.println(nums[i][j]);
      }
  }
  
  // 增强 for 循环（for-each）
  int totalLength = 0; // 元素的总个数
  for (int[] outerArr : arr) {
      for (int ele : outerArr)
          System.out.println(ele);
          totalLength ++;
      }
  }
  

操作数组的工具类

• java.lang.System 类中数组拷贝的类方法
  void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)：从 源数组 src 的 srcPos 位置 复制元素到 目标数组 dest 的 destPos 位置，复制的数组元素的个数为 length

Arrays

java.util.Arrays 中的类方法：

1. String toString(Object[] arr)：将 a 数组转换成一个字符串，括在方括号（"[]"）中，相邻元素用字符 ", "（逗号加空格）分隔
2. void sort(Object[] a)：根据元素的自然顺序对指定对象数组按升序进行排序，数组中的所有元素都必须实现 Comparable 接口（jdk1.7 后，对于原始数据类型，使用双轴快速排序（Dual-Pivot QuickSort），对于对象数据类型，使用 TimSort）
3. void sort(T[] a, Comparator<? super T> c)：根据指定比较器产生的顺序对指定对象数组进行排序
4. void parallelSort(Object[] a)：以并发的方式对 a 数组的数组元素进行排序
5. void setAll(T[] array, IntFunction<T> generator)：使用提供的函数计算每一个元素的值，对指定数组中的所有元素进行设置
6. void parallelSetAll(T[] array, IntFunction<T> generator)：以并发的方式，使用提供的函数计算每一个元素的值，对指定数组中的所有元素进行设置
7. type binarySearch(Object[] a, type key)：使用二分法查询 key 元素值在 a 数组中出现的索引，如果 a 数组不包含 key 元素值，则返回 - (插入点 + 1)（调用该方法时要求数组中元素已经按升序排列；插入点为第一个大于 key 的元素索引）
8. boolean equals(Object[] a, Object[] a2)：如果 a 数组和 a2 数组的长度相等，且 a 数组和 a2 数组的数组元素也一一相同，该方法将返回 true
9. Object[] copyOf(Object[] original, int newLength)：复制 original 数组，截取或用 0（数值类型）、false（布尔类型）或者 null（引用类型）填充，以使新数组的长度为 newLength
10. List<T> asList(T... a)：把一个引用类型的数组或指定个数的对象转换成固定长度的 List（Arrays.ArrayList），只能遍历访问该集合里的元素，不可增加、删除该集合里的元素，否则会引发 UnsupportedOperationException 异常（对数组元素的修改，会影响转化过来的集合）

Integer[] integers = list.toArray(new Integer[0]); // List<Integer> 转 Integer[]
List<Integer> list = Arrays.asList(integers); // Integer[] 转 List<Integer>
Integer[] integers = Arrays.stream(ints).boxed().toArray(Integer[]::new); // int[] 转 Integer[]
int[] ints = Arrays.stream(integers).mapToInt(Integer::valueOf).toArray(); // Integer[] 转 int[]
List<Integer> list = Arrays.stream(ints).boxed().collect(Collectors.toList()); // int[] 转 List<Integer>，不能使用 Arrays.asList
int[] ints = list.stream().mapToInt(Integer::valueOf).toArray(); // List<Integer> 转 int[]